Distributed checksum calculation for communication packets

ABSTRACT

A packet generator includes a checksum calculator configured to distinguish, in a communication packet belonging to a sequence of packets, between (i) one or more constant values of a header of the packet, the one or more constant values remaining unchanged across the packets in the sequence, (ii) a payload of the packet, and (iii) one or more variable values of the header, the one or more variable values changing among the packets in the sequence, to determine a constant-values partial checksum calculated over the constant values of the header, to calculate a payload partial checksum over the payload, to calculate a final checksum value for the packet based on (i) the constant-values partial checksum, (ii) the payload partial checksum and (iii) the variable values of the header, and to insert the final checksum value into the packet. An egress interface transmits the packet over a network.

CROSS-REFERENCE TO RELATED APPLICATIONS

This application claims the benefit of U.S. Provisional Patent Application 62/591,590, filed Nov. 28, 2017, and U.S. Provisional Patent Application 62/650,187, filed Mar. 29, 2018, whose disclosures are incorporated herein by reference in their entirety.

FIELD OF THE DISCLOSURE

The present disclosure relates generally to network communication, and particularly to methods and systems for calculation of checksums for network packets.

BACKGROUND

Various electronic systems involve transmission of media content over a packet network, such as, for instance, an Ethernet network. For example, automotive communication systems may use a Local-Area Network (LAN) for transferring video content acquired by a video camera, and/or other media content acquired by various other sensors such as velocity sensors, accelerometers, audio sensors, infra-red sensors, RADAR sensors, ultrasonic sensors, rangefinders, and the like, to a vehicle computer.

The description above is presented as a general overview of related art in this field and should not be construed as an admission that any of the information it contains constitutes prior art against the present patent application.

SUMMARY

An embodiment that is described herein provides a packet generator including a checksum calculator and an egress interface. The checksum calculator is configured to distinguish, in a communication packet belonging to a sequence of communication packets, between (i) one or more constant values of a header of the communication packet, the one or more constant values remaining unchanged across the communication packets in the sequence, (ii) a payload of the communication packet, and (iii) one or more variable values of the header of the communication packet, the one or more variable values changing among the communication packets in the sequence, to determine a constant-values partial checksum calculated over the constant values of the header, to calculate a payload partial checksum over the payload, to calculate a final checksum value for the communication packet based on (i) the constant-values partial checksum, (ii) the payload partial checksum and (iii) the variable values of the header, and to insert the final checksum value into the communication packet. The egress interface is configured to transmit the communication packet, including the final checksum value, over a communication network.

In some embodiments, the checksum calculator is configured to determine the constant-values partial checksum and to calculate the payload partial checksum independently of one another. In an embodiment, the checksum calculator is configured to determine the constant-values partial checksum before the payload is received in the packet generator. In another embodiment, the checksum calculator is configured to calculate the constant-values partial checksum upon initialization of the packet generator and to store the calculated constant-values partial checksum in a memory, or to read from the memory an offline-calculated constant-values partial checksum.

In some embodiments, the header of the communication packet spans one or more data words, and the checksum calculator is configured to determine the constant-values partial checksum by zeroing any bits of the data words that do not belong to the constant values of the header, and then calculating the constant-values partial checksum over non-zeroed bits of the data words corresponding to the constant values. In an example embodiment, the checksum calculator is configured to calculate the payload partial checksum over the payload in parallel with the payload being written into the memory buffer.

In another embodiment, the variable values of the header span a first number of data words, and the checksum calculator is configured to calculate the final checksum by rearranging the variable values of the header in a second number of data words, smaller than the first number, and calculating the final checksum over the second number of data words. In yet another embodiment, the checksum calculator is configured to calculate the final checksum value in parallel with transmission of the communication packet, and to complete calculation of the final checksum value and insertion of the final checksum value into the communication packet before a transmission time of the final checksum value.

In some embodiments the packet generator further includes a transmit (TX) First-In First-Out (FIFO) buffer configured to hold at least the payload of the communication packet, and the checksum calculator includes (i) input-side logic, which is coupled to an input of the FIFO buffer and configured to insert the payload partial checksum into a status word that propagates via the FIFO buffer together with the payload, and (ii) output-side logic, which is coupled to an output of the FIFO buffer and configured to extract the status word from the FIFO buffer, calculate the final checksum value based on the payload partial checksum in the status word, and insert the final checksum value into the communication packet.

There is additionally provided in accordance with an embodiment described herein, a packet generation method including, in a communication packet belonging to a sequence of communication packets, distinguishing between (i) one or more constant values of a header of the communication packet, the one or more constant values remaining unchanged across the communication packets in the sequence, (ii) a payload of the communication packet, and (iii) one or more variable values of the header of the communication packet, the one or more variable values changing among the communication packets in the sequence. A constant-values partial checksum, calculated over the constant values of the header, is determined. A payload partial checksum is calculated over the payload. A final checksum value is calculated for the communication packet based on (i) the constant-values partial checksum, (ii) the payload partial checksum and (iii) the variable values of the header. The final checksum value is inserted into the communication packet. The communication packet, including the final checksum value, is transmitted over a communication network.

The present disclosure will be more fully understood from the following detailed description of the embodiments thereof, taken together with the drawings in which:

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1 is a block diagram that schematically illustrates a media-to-Ethernet converter, in accordance with an embodiment that is described herein;

FIG. 2 is a block diagram that schematically illustrates a packetizer used in the media-to-Ethernet converter of FIG. 1, in accordance with an embodiment that is described herein;

FIG. 3 is a flow chart that schematically illustrates a method for media-to-Ethernet conversion, in accordance with an embodiment that is described herein;

FIG. 4 is a flow chart that schematically illustrates a method for packet generation, in accordance with an embodiment that is described herein;

FIG. 5 is a diagram showing an example header format of a packet, in accordance with an embodiment that is described herein; and

FIG. 6 is a diagram that schematically illustrates a process of distributed generation of a checksum for a communication packet, in accordance with an embodiment that is described herein.

DETAILED DESCRIPTION OF EMBODIMENTS

Embodiments that are described herein provide improved methods and apparatus for converting media content into network communication packets. Some disclosed embodiments provide improved methods and apparatus for calculating checksum values for communication packets that are being generated.

The disclosed techniques are especially useful in applications that require very low latency. One example of such an application is an automotive system, in which video content, and/or outputs of various sensors, is to be converted into Ethernet packets and transmitted to a central vehicle computer. The techniques described herein are useful, however, in various other applications, which are not necessarily latency-sensitive.

The description that follows refers in some locations mainly to video content, by way of example only. It is specifically intended, however, that other suitable types of sensors and other suitable types of data, including but not limited to velocity sensors and velocity data, accelerometers and acceleration data, audio sensors and audio data, infra-red sensors and infra-red data, radar sensors and radar data, lidar sensors and lidar data, ultrasonic sensors and ultrasonic data, rangefinders and proximity data, collision avoidance imaging and collision avoidance imaging data, and the like, are addressed, as well, are suitably handled by apparatus having components and functionalities described herein, and are covered by this description and the claims that follow.

The description that follows refers in some locations mainly to raw media content that is provided in a sequence of media frames. It is specifically intended, however, that other suitable types of data, not necessarily framed and not necessarily media, e.g., streamed media or sporadic data provided by one or more sensors, are addressed, as well, are suitably handled by apparatus having components and functionalities described herein, and are covered by this description and the claims that follow.

In some embodiments, the disclosed techniques are performed by a media-to-Ethernet converter, which comprises a conversion pipeline implemented entirely in hardware. The conversion pipeline comprises a media input stage followed by an Ethernet stage. The media input stage is configured to receive a sequence of media frames carrying raw video content from a media source, e.g., a video camera. The Ethernet stage comprises a packetizer, which is configured to convert the media frames into a sequence of data packets that are compliant with Ethernet or other suitable data network standards. Although the description that follows refers mainly to Ethernet, by way of example, it is specifically intended for the term Ethernet to encompass any suitable current or future packet based data network.

In some embodiments the packetizer converts media frames into Ethernet packets by generating Ethernet headers, on-the-fly, without writing frames into memory or subsequently reading frames from memory as the Ethernet packets are being formed, and appending portions of the media frames to the Ethernet headers. The sequence of Ethernet packets is transmitted over an Ethernet network, e.g., an in-car Local-Area Network (LAN), by an Ethernet Medium Access Control (MAC) engine followed by an Ethernet physical-layer (PHY) interface.

The media-to-Ethernet converter typically comprises a Central Processing Unit (CPU) or other suitable processor that runs suitable software, e.g., for communication with a host system, for general management and configuration, and/or other non-real-time tasks. The conversion pipeline (the “data path”), however, is implemented entirely in hardware in an embodiment. Moreover, the data path does not involve any Direct Memory Access (DMA) operations or interrupts, in an embodiment. The disclosed media-to-Ethernet conversion process is therefore characterized by extremely low latency.

For example, the packetizer typically appends a portion of a video frame to a corresponding packet header before the video frame is fully received by the media input stage. Similarly, the Ethernet MAC engine typically starts outputting an Ethernet packet, which comprises payload bits belonging to a video frame, before this video frame is fully received by the media input stage.

Data buffering, when used in the conversion pipeline, is used for compensating for differences in clock speed between different stages of the pipeline, not for batch processing of entire frames. As such, data buffering in the conversion pipeline is limited to a small fraction of a video frame and is generally significantly less.

Inasmuch as the end-to-end latency of the conversion pipeline, from inputting data, such as a pixel, into the media input stage until outputting the corresponding payload bits by the Ethernet PHY interface, is designed to be much less than the time duration required to receive a complete media frame, such as video frame, buffers are disposed in the conversion pipeline to synchronize between receipt of a media frame and the time required by the pipeline to convert the media frame into an Ethernet packet, in an embodiment.

In some embodiments that are described herein, the packetizer comprises a header generator, which generates the packet headers on-the-fly using one or more configurable hardware registers (referred to as a “header template”) in accordance with a predefined header format. The header format specifies the various header fields, e.g., in the form of a bit-pattern.

In some embodiments, the header format specifies the types and/or numerical values of the header fields. Examples of types of header fields comprise (i) a “constant” field whose value is constant across the sequence of packets, (ii) an “incremented” field whose value is incremented in successive packets in accordance with a rule, and (iii) a “calculated” field whose value is calculated over at least part of the payload of the respective packet. When generating a header for a certain packet, the header generator calculates a value for each field according to the type of field, as specified in the header format.

In some embodiments, the header format is selected from a set of predefined header formats, e.g., during production of the media-to-Ethernet converter. This feature enables, for example, the same media-to-Ethernet converter to operate in different host systems that use different communication protocols and require different header formats.

In some embodiments, the packetizer is configured to calculate checksums for the communication packets in a distributed manner. In an embodiment, the header format comprises a classification of the values in the packets into at least (i) one or more constant values of the header of the communication packet, i.e., values that remain unchanged across the communication packets in the sequence, (ii) a payload of the communication packet, and (iii) one or more variable values of the header of the communication packet, i.e., values that change among the communication packets in the sequence.

In this embodiment, a checksum calculator is configured to calculate partial checksums for each communication packet: (i) a partial checksum for constant-values (also referred to as “raw header checksum”) that is calculated over the constant values of the header, and (ii) a payload partial checksum that is calculated over the payload. The checksum calculator calculates a final checksum value for the communication packet based on (i) the constant-values partial checksum, (ii) the payload partial checksum, and (iii) the variable values of the header. The checksum calculator inserts the final checksum value into the communication packet to be transmitted. As will be explained below, this scheme lends itself for efficient hardware implementation and achieves very small latency.

In the disclosed embodiments, the calculations of the various partial checksum values are independent of one another. The technique of separate calculation of partial checksum values is enabled by the fact that, in the disclosed embodiments, the checksum function is commutative. The term “commutative” in this context means that the overall checksum calculation can be broken-down into sub-calculation that are performed in any desired order, without affecting the correctness of the result. Checksums based on summations and/or XOR calculations, for example, meet this property.

By calculating partial checksum values, checksum calculation is spread over time, thus better enabling the calculation of a checksum value for a packet within the real-time constraints of the media-to-Ethernet converter for converting media frames into communications packets.

Example implementations of the media-to-Ethernet converter, and associated methods, are described and explained in detail below.

FIG. 1 is a block diagram that schematically illustrates a media-to-Ethernet converter 20, in accordance with an embodiment that is described herein. In the present example, media-to-Ethernet converter 20 is deployed as part of a safety or self-drive sub-system in an automotive vehicle, and is used for converting video, or other sensor data, acquired by a camera, or other sensor, into Ethernet frames. Alternatively, similar media-to-Ethernet converters can be used in other types of host systems and applications.

In the embodiment of FIG. 1, media-to-Ethernet converter 20 comprises a hardware-implemented conversion pipeline comprising a media input stage 24, an Ethernet stage 28 and an Ethernet Physical-layer (PHY) stage 32. The conversion pipeline receives a sequence of raw media frames, and outputs a sequence of Ethernet packets whose payloads carry the media content. A Central Processing Unit (CPU) 36 manages and configures the various elements of the conversion pipeline, in an embodiment. CPU 36 typically is responsible for communication with the host system, and for various other functions that are not on the real-time data-path of media-to-Ethernet conversion.

In an embodiment, media-to-Ethernet converter 20 comprises a memory 38, typically a Random Access Memory (RAM). Memory 38 is used, for example, by CPU 36 for storing suitable information. Memory 38 typically is not connected and not accessed by the conversion pipeline. As explained herein, the conversion pipeline converts the media frames into the Ethernet packets without writing or reading media frames to and from memory.

In an embodiment, media input stage 24 comprises a sensor interface 40, a multiplexer (MUX) 44, a media-to-elasticity-buffer (media-to-ebuf) converter 48, a media encoder 52, and a MUX 56. Sensor interface 40 is configured to connect to a sensor and receive the sequence of raw media frames. In the present example, the sensor comprises an image sensor, e.g., a video camera, and the media frames comprise raw video frames, however in other embodiments the sensor comprises any other suitable sensor.

In the present context, the term “raw” means that the video is not compressed, so that each pixel is represented by a respective numerical value independently of other pixels and/or other video images in the sequence. Any suitable video format can be used. Example video formats include, for example, without limitation, RAW8, RAW10, RAW12, RAW14, RGB888, RGB656, YUV444, YUV422, YUV420 and YUV411. Such formats differ from one another, for example, in pixel depth (number of bits per pixel) and/or in chroma sample rate. Sensor interface 40 may support any suitable camera interface, or multiple interfaces, such as, for example, without limitation, various parallel interfaces having horizontal/vertical sync (HSYNC/VSYNC), MIPI CSI-2, MIPI CSI-3, or any other interface. The disclosed techniques are not limited to raw video, but are applicable to any video format. Moreover, the disclosed techniques are not limited to video, and are applicable to various other types of media as noted above.

In various embodiments, sensor interface 40 receives the video as a serial bit stream or as a parallel word stream. MUX 44 routes the video frames to media-to-ebuf converter 48 or to media encoder 52, as appropriate. Typically, media encoder 52 is used when the video is to be compressed before egress from the media-to-Ethernet converter. Media-to-ebuf converter 48 is used otherwise, i.e., when the raw video is to be transmitted without compression.

Typically, media-to-ebuf converter 48 is configured to convert the incoming media, which complies with one of several possible formats, to a fixed format that is expected at the input of an elasticity buffer (ebuf) 60 in Ethernet stage 28. media-to-ebuf converter 48 typically has a sensor-specific input interface. For raw video, for example, the input interface may comprise eight, ten, twelve or sixteen bits of pixel data, plus sideband signals that define vertical and horizontal synchronization information (e.g., v_sync, h_blank). The synchronization information determines the start and end of each video frame, and the start and end of each video line within the frame. This synchronization information may also be coded into the pixel data.

In some embodiments, the output of media-to-ebuf converter 48 is provided to ebuf 60. The format at the input of ebuf 60 is typically sensor-independent. In an embodiment, the input to ebuf 60 comprises 32-bit data, plus 4-bit byte-valid information and 4-bit sideband information. The sideband information signals events such as start and end of a video frame, video line and/or video unit. Media-to-ebuf converter 48 collects the incoming pixel information, derives (depending on the input interface protocol) synchronization information either from the input sideband signals or from the pixel data, and assembles the data in 32-bit groups that are accompanied by byte valid information and 4-bit sideband information, as expected by ebuf 60. Media-to-ebuf converter 48 is typically specific to the application and sensor type. The output of the media-to-ebuf converter 48 typically has the same format regardless of application and sensor type. Therefore, the design of Ethernet stage 28 and its components is independent of the sensor and media type.

The output of media encoder 52 or of media-to-ebuf converter 48 is provided via MUX 56 as the output of media input stage 24. Control of MUX 56 is addressed in detail in FIG. 2 below. In an embodiment, media input stage 24 parses the video stream at the boundaries between video frames, or other suitable boundaries in media frames, and inserts suitable frame markers such as Start-Of-Frame (SOF) and End-Of-Frame (EOF) markers. In other embodiments, e.g., when packetizing media that is not framed, e.g., streaming media or sporadic data from a sensor, any other suitable scheme can be used for parsing the media or data into packets.

When the video applicable video format comprises Network Abstraction Layer Units (NALUs), such as in H.264 compressed video, frame markers may comprise Start-Of-NALU (SON) and End-Of-NALU (EON) markers. After compression, the video frames and the NALUs have variable lengths. Ethernet packets of up to 1,500 bytes are typically too small to carry a complete video frame. For raw (uncompressed) video, an Ethernet packet typically carries one video line or a fraction of a line. In such embodiments, SON/EON markers serve as start/end of line indications. For H.264 compressed video, for instance, media encoder 52 is typically configured to produce NALUs of a size that fits into one Ethernet packet. In these embodiments, SON/EON markers serve as indications of the start and end of NALUs.

In some embodiments, sensor interface 40 receives media content from one or more other sensors for conversion into Ethernet packets, either alternatively or additionally to the video frames. Example types of sensors and content include, but are in no way limited to, velocity sensors and velocity data, accelerometers and acceleration data, audio sensors and audio data, infra-red sensors and infra-red data, radar sensors and radar data, lidar sensors and lidar data, ultrasonic sensors and ultrasonic data, rangefinders and proximity data such as in collision avoidance data and applications, and the like.

In some embodiments, media input stage 24 is implemented separately from the rest of media-to-Ethernet converter 20, e.g., on a standalone semiconductor die or in a standalone device. Additionally or alternatively, in some embodiments Ethernet stage 28 is implemented on a standalone die that is separate from media input stage 24 and/or from CPU 36. In an embodiment, media input stage 24, Ethernet stage 28 and CPU 36 are packaged together in a unified package, or are respectively disposed on a circuit board and coupled together. In an alternative embodiment, media input stage 24, Ethernet stage 28 and CPU 36 are formed as separate modules and disposed on the same integrated circuit substrate.

Such implementations enable, for example, media-to-Ethernet converter 20 to be fabricated modularly, e.g., to suit different host systems using different variants of media input stage 24 but the same Ethernet stage 28. Different variants of media input stage 24 may differ from one another, for example, in the types of sensors and/or media formats they support.

The media content (in the present example video content) from media input stage 24 is provided to Ethernet stage 28. In some embodiments, Ethernet stage 28 comprises elasticity buffer (ebuf) 60, a packetizer 64, and an Ethernet Medium Access Control (MAC) engine 84.

Elasticity buffer (ebuf) 60 buffers the video stream provided by media input stage 24, including frame markers if used. Ebuf 60 compensates for rate variations and bursts in the output of media input stage 24. Bursts at the output of media input stage 24 occur, for example, when the video is being encoded by media encoder 52, which typically outputs one code word at a time with idle intervals between code words. The size of ebuf 60 is typically equivalent to a fraction of a video frame.

In some embodiments, the size of elasticity buffer 60 is typically derived from a worst-case estimation of the difference in clock speed between media input stage 24 (whose clock is typically synchronized with the sensor's pixel clock) and Ethernet stage 28 (whose clock speed is typically dependent on the network speed, e.g., 1 Gb/s or 100 Mb/s).

Packetizer 64 converts the sequence of media frames into a sequence of Ethernet packets, as described in detail below. Throughout the present disclosure and in the claims, clear distinction is made between the terms “frame” and “packet.” The term “frame” refers to a structural data unit of the media protocol of the media (e.g., video) entering media-to-Ethernet converter 20. The term “packet” refers to a structural data unit of the network communication protocol (e.g. Ethernet) used for communication over the data network.

In the example of FIG. 1, packetizer 64 comprises a transmit First-In First-Out memory (TX FIFO) 68, a header format selector 72, a header generator 76, a checksum calculator 78 and a MUX 80. Further aspects of the internal structure of packetizer 64 are addressed in FIG. 2. The operation of packetizer 64 is explained in detail further below. In an embodiment, header format selector 72, among other tasks, performs packet-field classification for the purpose of checksum calculation.

The Ethernet packets produced by packetizer 64 are transmitted over an Ethernet network (not shown in the figures) by Ethernet MAC engine 84 and Ethernet PHY interface 32, which perform the MAC and PHY layers of the Ethernet protocol, respectively. As noted above, MAC engine 84 typically starts encapsulating and outputting an Ethernet packet, which comprises payload bits belonging to a certain video frame, before this video frame is fully received by media input stage 24. The Ethernet packets may be sent over the network to any suitable destination, e.g., a central vehicle computer.

FIG. 2 is a block diagram that schematically illustrates the internal structure of packetizer 64 used in media-to-Ethernet converter 20 of FIG. 1, in accordance with an embodiment that is described herein. The figure focuses on the ancillary logic circuitry surrounding TX FIFO 68. Generally speaking, TX FIFO 68 is used for buffering media content that is to be sent as payload of a packet, possibly along with relevant metadata, while the ancillary logic circuitry performs the operations and calculations for generating the header for that packet.

In the example of FIG. 2, the ancillary logic circuitry of packetizer 64 comprises a payload checksum calculation module 88, a header template module 92, a packet counter 96, a TX packet state machine (SM) 100 and a TX read SM 104. Header format selector 72 and header generator 76 shown in FIG. 1 are not shown in the present figure, for the sake of clarity. Payload checksum calculation module 88 and header template 92 are typically part of header generator 76.

Payload checksum calculation module 88 calculates the applicable checksum over the payload of the current Ethernet packet. Header template module 92 (also referred to simply as “header template”) holds the header field values for the current Ethernet packet, e.g., in bit-pattern format in one or more hardware registers. Packet counter 96 counts the Ethernet payloads waiting for transmission. A counter value larger than zero means that the payload of at least one Ethernet packet is complete and ready for transmission in TX FIFO 68. Typically, TX packet SM 100 increments counter 96 when a payload is fully written into TX FIFO 68, and TX read SM 104 decrements counter 96 when a payload is fully streamed via MUX 80.

In an embodiment, under control of TX packet SM 100, video content is written from ebuf 60 into TX FIFO 68. SM 100 also divides the video stream into Ethernet packets. SM 100 scans the video stream, searching for frame markers, line markers and/or NALU markers (e.g., SOF, EOF, SON, EON). Based on the frame markers, SM 100 assigns portions of the video content between frame markers to become payloads for respective Ethernet packets.

It is noted that typically a single video frame is split into portions that are spread across several Ethernet packets. SM 100 limits the size of each portion so that a resulting packet payload will produce a packet that is less than or equal to the Maximum Transmission Unit (MTU) size according to a transmission protocol, such as for example TCP or UDP, which is used for transmitting packets. In addition, in an embodiment, SM 100 starts each new video frame, line or NALU in a new Ethernet packet. SM 100 typically marks the end of a payload by inserting an End-Of-Packet (EOP) marker into the video stream in TX FIFO 68.

In an example implementation, if the payload of a certain packet reaches the MTU size and no EOF or EON is encountered, SM 100 terminates the current payload, and sets a “fragmentation” flag. SM 100 typically inserts the fragmentation flag into the video stream in TX FIFO 68. The fragmentation flag is typically read from TX FIFO 68 by TX read SM 104 and written to header template 92. SM 100 also terminates the payload of the current Ethernet packet in response to identifying EOF or EON in the video stream, so that the next video frame, line or NALU will begin in a new Ethernet packet.

In an embodiment, SM 100 also controls payload checksum calculation module 88. SM 100 writes the video content from ebuf 60 to payload checksum calculation module 88, in parallel to writing the video content into TX FIFO 68. For each Ethernet packet, SM 100 waits until checksum calculator 88 has finished calculating the payload checksum, and then inserts the checksum value into the video stream in TX FIFO 68. The checksum value is typically extracted from TX FIFO 68 by TX read SM 104 and written to header template 92, thereby populating a checksum value in a packet header in accordance with header template 92.

In an embodiment, Tx SM 100 also generates a timestamp value for each Ethernet packet, and inserts the timestamp value into the video stream in TX FIFO 68. Any suitable trigger can be used for generating the timestamp. The timestamp value typically is extracted from TX FIFO 68 by TX read SM 104 and written to header template 92. Typically, SM 100 also writes the length of the payload into the video stream in TX FIFO 68, to be extracted and written to the header template by SM 104.

In an embodiment, Tx SM 100 writes the header field values (timestamp, payload checksum, payload length) in a dedicated word inserted into the video stream in TX FIFO 68. When the above operations are complete, TX packet SM 100 increments packet counter 96 to indicate that another payload is ready for transmission.

TX read SM 104 is typically responsible, per Ethernet packet, for reading the payload data and associated header field values (timestamp, payload checksum, payload length) from TX FIFO 68, updating header template 92, and transmitting the header and payload via MUX 80 to Ethernet MAC engine 84. Thus, TX read SM 104 serves as a selector that selectively controls MUX 56 to alternate between header and payload inputs, so as to generate complete Ethernet packets.

In an embodiment, in response to detecting that packet counter 96 has a non-zero value (meaning that at least one payload is ready in TX FIFO 68), TX SM 104 is triggered to begin processing the next Ethernet packet. Specifically, in an embodiment, SM 104 then reads the dedicated word that comprises the header field values (timestamp, payload checksum, payload length) from TX FIFO 68, and populates header template 92 with these values. Before updating the checksum field in the header template, SM 104 typically calculates a final checksum value for the Ethernet packet, based on the payload checksum provided by SM 100, and possibly one or more additional partial checksum values for the packet.

In some embodiments, the final checksum value can be viewed as a sum of (i) a partial checksum for constant-value header fields (which is constant and calculated once at initialization of the header template), (ii) a partial checksum for values of variable-header fields (including timestamp and packet length calculated from header length plus payload length, which are not available before the payload is fully written to TX FIFO 68) and (iii) a partial checksum for the payload. Calculation of the final checksum typically takes several clock cycles, e.g., by accumulating sixteen bits per clock cycle. In the embodiment described herein, the partial checksum for the constant-value header fields and the partial checksum for the payload are each calculated separately. The two resulting partial checksums are then included in a final checksum calculation, which also includes the values of variable-header fields. In an alternative embodiment, each of the three partial checksums above is calculated separately, and the partial checksums are then added together.

In some embodiments, media-to-Ethernet converter 20 comprises separate hardware for calculating each type of partial checksum. In other embodiments, some hardware commonality is used, i.e., some of the hardware in media-to-Ethernet converter 20 is used for calculating two or more types of partial checksum. In either case, the calculation of one type of partial checksum is typically independent of calculation of any other type of partial checksum.

When the current Ethernet packet is ready for egress from media-to-Ethernet converter 20, SM 104 typically causes the header of the packet to be transmitted from header template 92, for example by signaling MUX 80 to select header template 92. After transmitting the header, Tx SM 104 signals MUX 80 to select TX FIFO 68, which subsequently begins transmitting the payload from the TX FIFO via MUX 80. Streaming of the payload continues until reaching the EOP marker (which was inserted by TX SM 100 into the video stream in TX FIFO 68). When the packet transmission is completed, TX SM 104 decrements packet counter 96. Upon completion of packet transmission, SM 104 also performs additional actions, such as updating certain header fields for the next packet (e.g., fragmentation offset or sequence number), in an embodiment.

The configurations of media-to-Ethernet converter 20 and its components, such as media input stage 24 and Ethernet stage 28 including packetizer 64, as shown in FIGS. 1 and 2, are example configurations that are depicted solely for the sake of clarity. In alternative embodiments, any other suitable configurations can be used. Elements that are not mandatory for understanding of the disclosed techniques have been omitted from the figures for the sake of clarity.

The different elements of media-to-Ethernet converter 20 may be implemented using dedicated hardware or firmware, such as using hard-wired or programmable logic, e.g., in an Application-Specific Integrated Circuit (ASICs) or Field-Programmable Gate Array (FPGA). Elasticity buffer 60 and TX FIFO 68 may comprise any suitable type of memory, e.g., Random Access Memory (RAM).

Typically, CPU 36 comprises a general-purpose processor, which is programmed in software to carry out the functions described herein (e.g., communication with a host system, general management, and/or other tasks that do not necessarily need to be performed in real time or at wire-speed). The software may be downloaded to the processor in electronic form, over a network, for example, or it may, alternatively or additionally, be provided and/or stored on non-transitory tangible media, such as magnetic, optical, or electronic memory.

FIG. 3 is a flow chart that schematically illustrates a method for media-to-Ethernet conversion, in accordance with an embodiment that is described herein. The method begins with sensor interface 40 receiving raw video from the image sensor, at an input operation 110. Media input stage 24 optionally encodes the raw video content. Media input stage 24 outputs the video content for buffering in ebuf 60, at an elasticity buffering operation 114.

At a parsing operation 118, packetizer 64 assigns portions of the video to serve as payloads of respective Ethernet packets. At a packet generation operation 122, packetizer 64 generates headers for the Ethernet packets. At a transmission operation 126, packetizer 64 streams the headers and payloads of the Ethernet packets, en-route to MAC engine 84 and PHY interface 32.

In some embodiments, media-to-Ethernet converter 20 is configurable to selectively support packet header formats of various protocols. Ethernet-based header types that differ from one another in header format and/or content comprise, for example, Ethernet MAC header, IPv4 header, IPv6 header, User Datagram Protocol (UDP) header, Real-Time Protocol (RTP) header, RTP header for RAW Video Format (RVF), Audio Video Transport Protocol (AVTP) header, AVTP header for RVF, Motion JPEG (MJPEG) header and/or other headers compliant with other suitable Ethernet or other protocols.

Each header format specifies a certain header-field configuration, e.g., the type, definition, location in the header, size, and possibly numerical value of each header field. Different header formats may differ from one another in any such parameter, for example. In various embodiments, media-to-Ethernet converter 20 supports any suitable subset of packet header formats, e.g., from a single format to all formats. CPU 36 typically holds the definitions of the (one or more) header formats supported by media-to-Ethernet converter 20, and configures packetizer 64 with the header format to be used for conversion.

Typically, selection and configuration of the header format are performed offline, not during normal operation. In such embodiments, CPU 36 provides the appropriate header format to header format selector 72 offline, e.g., on initialization, during production or during post-production testing. In this manner, a given media-to-Ethernet converter 20 that operates in a given host system will always use the same header format, in an embodiment, but different media-to-Ethernet converters of the same type can be installed and operated in various host systems that require different header formats. In alternative embodiments, however, CPU 36 may instruct header format selector 72 to switch to a different header format, from among the supported formats, at any suitable time, e.g., during normal operation in a host system.

In either case, header format selector 72 configures header generator 76 with the selected header format to be used. Header generator 76 generates headers for the Ethernet packets in accordance with the selected header format. As explained above, header template 92 (shown in FIG. 2) comprises one or more hardware registers that packetizer 64 populates, per Ethernet packet, with the numerical values of the header fields for that packet. When fully populated, packetizer 64 streams the content of header template 92 followed by the corresponding packet payload.

In some embodiments, the definition of a header format distinguishes between two or more different types of header fields. In these embodiments, the header format provided to header generator 76 specifies the type of each header field. When populating header template 92 for generating the header of the current Ethernet packet, header generator 76 calculates the numerical value differently for each type of field.

In an example embodiment, the header format classifies the header fields into the following types:

-   -   “Constant”-type fields. The numerical value of a “constant”-type         field is retained constant by header generator 76 across the         sequence of Ethernet packets. Examples of “constant”-type fields         are IP version, and source and destination MAC and IP addresses,         to name just a few. In some embodiments, the numerical value of         a “constant”-type field is set in header template 92 before the         media content is received, e.g., offline when the header format         is selected and initialized.     -   “Incremented”-type fields. The numerical value of an         “incremented”-type field is incremented by header generator 76         from one packet to the next in accordance with a rule. The rule         is also specified in the header format. In some embodiments,         although not necessarily, the rule defines that the numerical         value is to be increased by one from one packet to the next. An         example of an “incrementing”-type field is a sequence number. In         some embodiments, the numerical value of an “incrementing”-type         field is set in header template 92 before the payload for this         packet is fully available, e.g., as soon as the previous header         has been transmitted and header template 92 can be modified.     -   “Calculated”-type fields. The numerical value of a         “calculated”-type field is calculated by header generator 76 in         a predefined manner, e.g., a formula. In some embodiments,         although not necessarily, header generator 76 calculates the         numerical value of a “calculated”-type field over at least part         of the payload of the respective packet. Examples of a         “calculated”-type fields are a checksum field and a length         (e.g., byte-count) field.

In some embodiments, header generator 76 does not necessarily increment an “incremented”-type field by one per packet. For example, if a video line does not fit into a single packet, then a video-line-number field within a header may be incremented by one only every two or three packets. As another example, a video-frame-number field may be incremented after the last packet of that video frame. The header may also have a sequence number for a video line spread across multiple packets, which is reset to 0 for each first packet of a line and then incremented in the following packets of the same line.

In some embodiments, header generator 76 does not necessarily calculate a “calculated”-type field over the payload. Some “calculated”-type fields may not depend on the payload at all. One example is a timestamp field that header generator 76 calculates by adding a configurable offset to the sampled Precision Time Protocol (PTP) Timer value. Another example is a “fragmentation offset” field value for a video line spreading across multiple packets. Header generator 76 calculates such a field by summing the byte-counts of the previous packets for the same video line.

Another example of a calculated header field is a flag (single-bit field) that indicates a certain event. For example, a flag indicating the last packet for a video frame may be calculated by header generator 76 from coincidence of end-of-frame and end-of-line indications. As another example, a “timestamp valid” (TV) field in an AVTP header may be set to 1 for all packets, or only for specific packets according to a scheme that is selected by a configuration register (e.g. TV=1 only for the first or last packet of a video frame). As yet another example, a hardware mechanism may set an error flag in a packet header upon detecting errors.

The header fields and header-field types listed above are depicted solely by way of example. In alternative embodiments, the header formats and header generator 76 supports any other suitable fields and/or types of header fields. An illustrative example of a header format, demonstrating the classification of the header fields into the various header-field types, is depicted in FIG. 5 below.

In some embodiments, header generator 76 sets the numerical value of a certain field in the registers of header template 92 by (i) reading the existing numerical value from the registers of the header template, (ii) performing some calculation on the existing numerical value to produce the updated value, and (iii) writing the updated numerical value to the registers of the header template. Such an update is performed, for example, in “incremented”-type fields, and also in some “calculated”-type fields such as checksums that are calculated over data spanning multiple Ethernet packets. Header generator 76 may perform this update between transmissions of successive Ethernet packets, at any time after the header of the previous packet has been transmitted.

FIG. 4 is a flow chart that schematically illustrates a method for packet generation, in accordance with an embodiment that is described herein. The method begins with header generator 76 obtaining the applicable header format from header format selector 72, at a format initialization operation 130.

At a value calculation operation 134, header generator 76 calculates the numerical values to be inserted in the fields of the header of the current Ethernet header being generated. As explained above, header generator 76 identifies one or more “constant”-type, “incremented”-type and/or “calculated”-type fields in the header format, and calculates the numerical value for each header field based on its type.

For example, for any “constant”-type field in the header format, header generator 76 retains the same constant value for all packets, at a constant-field calculation sub-operation 138. For any “incremented”-type field in the header format, header generator 76 increments the numerical value relative to the value in the previous packet in accordance with the rule, at an incrementing-field calculation sub-operation 142. For any “calculated”-type field in the header format, header generator 76 calculates the numerical value, at a calculated-field calculation sub-operation 146.

At a header-template population operation 150, header generator 76 populates the hardware registers of header template 92 with the numerical values calculated at operation 134 above. At a transmission operation 154, packetizer 64 streams the header and payload of the Ethernet packet, en-route to MAC engine 84 and PHY interface 32.

FIG. 5 is a diagram showing an example header format of a packet 160, in accordance with an embodiment that is described herein. In the present example, the header of packet 160 comprises a MAC header 164, followed by an IPv4 header 168, a UDP header 172 and an AVTP header 176. MAC header 164 corresponds to layer-2, and the other headers correspond to higher layers, e.g., layer-3, layer-4 and/or layer-5. The packet header is followed by the packet payload.

Each “constant”-type field in the packet header of packet 160 is marked as “CONST” or “C”. Each “incrementing”-type field is marked as “INC”. Each “calculated”-type field is marked as “CALC”. Flags (considered a special case of a “calculated”-type field) are marked as “F”.

As can be seen in the figure, the entire MAC header 164 is “constant”-type. IPv4 header 168, on the other hand, comprises fields of all types. For example, the “ver” field specifies the IP version and is thus constant. The “total_len” field is a “calculated”-type field that is calculated from the payload length and the protocol selection. The “ip_id” field is an “incrementing”-type field that is incremented by one per packet. The classification of the “flags” fragmentation offset (“frag_offs”) fields depends on whether IP fragmentation is supported or not. If supported, these fields are calculated for each packet. If not supported, these fields are constant.

UDP header 172 comprises both “constant”-type and “calculated”-type fields. The “udp_length” field, for example, is calculated per packet based on the payload length and the header length set by the protocol selection. AVTP header 176 comprises fields of all types. For example, the “sequence_num” field is an “incrementing”-type field that is incremented by one per packet. The “avtp_timestamp” is a “calculated”-type field comprising a calculated or sampled Precision Time Protocol (PTP) timer value. The “stream_data_length” is a “calculated”-type field calculated from the payload length. The “i_seq_num” and “line_number” fields are “incrementing”-type fields.

The packet header format shown in FIG. 5 is depicted purely by way of example, in order to demonstrate the use of the various types of packet-header fields. In alternative embodiments, any other suitable packet header formats can be used.

FIG. 6 is a diagram that schematically illustrates a process of distributed generation of a checksum for a communication packet, in accordance with an embodiment that is described herein. In various embodiments, any suitable type of checksum can be used. As noted above, the checksum is assumed to be commutative function, so that, for example, it is possible to divide the data words into two or more parts, calculate a partial checksum separately over each part in any desired order, and then combine the partial checksums to produce a correct final checksum value.

The commutative property also enables packing data values into a smaller number of data words, and calculate the checksum over the smaller number of data words, as long as (i) each data value retains its original bit position (bit significance), and (ii) no overlap is created between data values. The use of this technique for reducing latency is demonstrated below.

An example packet 170, used for demonstrating the checksum calculation process, is depicted on the left-hand side of the figure. In the present example, the packet is arranged in 16-bit data words, and checksum calculator 78 performs the checksum calculation using 16-bit word operations. In alternative embodiments, any other suitable word width can be used.

In an embodiment, as a preparatory step, the header format classifies the fields (also referred to as “values”) of packet 170 into the following types:

-   -   Values that do not participate at all in the checksum         calculation, e.g., the MAC header at the beginning of the         packet.     -   One or more constant values the packet header, i.e., values that         remains unchanged across the headers of the communication         packets in the sequence. In the example of packet 170, the         constant values are denoted C1, C2, C3, . . . , C9.     -   One or more values belonging to the payload of the communication         packet. In the example of packet 170, the payload values are         denoted “payload 1” . . . “payload n”.     -   One or more variable values of the packet header, i.e., values         that change from one header to another among the communication         packets in the sequence. In the example of packet 170, the         variable values are denoted a, b, c, . . . , j, k.

Typically, although not necessarily, the classification of fields is performed in advance, before the media frames are received for conversion, e.g., during design of the header format and/or header template for a certain protocol or protocol layer. In an example embodiment, header format selector 72 supports different header formats for different protocols and protocol layers. For each header format, configuration registers and multiplexers are implemented to select which of the header fields are directed to MUX 80, which in turn selects between header and payload transmission. These configuration registers also comprise control multiplexers that put together the optimized words for the calculation of the final checksum value.

In some embodiments, checksum calculator 78 performs a distributed process that calculates the checksum over the constant values of the packet header, the variable values of the packet header and the payload, and inserts the resulting checksum value into the appropriate checksum field in the packet header. The distributed process comprises three phases—a raw header checksum calculation phase 180, a payload checksum calculation phase 190, and a final checksum calculation phase 200. In a transmission phase 210, the packet is transmitted via MAC engine 84 and PHY interface 32 to the network. Phase 210 is typically triggered by signaling from packet counter 96 (FIG. 2), indicating that a payload is ready for transmission. Each of phases 180-210 is depicted in a respective column in FIG. 6.

In raw header checksum calculation phase 180, checksum calculator 78 calculates a partial checksum over the constant values the packet header (C1, C2, C3, . . . , C9 in the present example). This partial checksum is referred to herein as a constant-values partial checksum or raw header checksum. In an embodiment, calculator 78 calculates the constant-values partial checksum by:

-   -   In the data words of the header, zeroing the bits that do not         belong to the constant values.     -   Calculating the checksum over the data words of the header         (i.e., over the bits that were not zeroed).

Typically, checksum calculator 78 calculates the constant-values partial checksum in advance, before the media frames are received for conversion, e.g., on initialization, during production or during post-production testing. Checksum calculator 78 then stores the constant-values partial checksum in memory for later use. In these embodiments, the constant-values partial checksum is calculated once in advance, and then used in the checksum calculation of each packet.

In payload checksum calculation phase 190, checksum calculator 78 calculates a partial checksum over the packet payload (data words “payload 1” . . . “payload n” in the present example). This partial checksum is referred to herein as a payload partial checksum. Typically, checksum calculator 78 calculates the payload partial checksum while the payload data (e.g., video stream) is being written into TX FIFO 68. As described above with reference to FIG. 2, payload checksum calculator 88 (which is regarded part of checksum calculator 78) receives the payload data from elasticity buffer 60, calculates the payload partial checksum, and inserts the payload partial checksum into a FIFO status word that propagates with the payload (e.g., video stream) in TX FIFO 68.

In final checksum calculation phase 200, checksum calculator 78 calculates the final checksum based on (i) the constant-values partial checksum (from phase 180), (ii) the payload partial checksum (from phase 190), and (iii) the variable values of the packet header. Checksum calculator 78 then inserts the final checksum value into the appropriate checksum field of the packet.

In some embodiments, checksum calculator 78 calculates the final checksum while the packet header is being streamed and transmitted to the network via MUX 80, MAC engine 84 and PHY interface 32. In these embodiments, the final checksum calculation must be completed before the checksum field is due for streaming via MUX 80.

In the example of FIG. 6 (see the two right-most columns) the checksum field is streamed via MUX 80 on the 10^(th) clock cycle from the beginning of transmission phase 210. As such, in order not to cause additional delay, checksum calculator 78 has to generate the final checksum value before the checksum field is streamed via MUX 80, i.e. in nine clock cycles or less.

In some embodiments, in order to meet the above timing constraint, checksum calculator 78 rearranges the variable values of the packet header in a smaller number of data words (smaller than the number of data words in which the variable values are found in the original packet header). In the example of FIG. 6, the variable values of the packet header (a, b, c, . . . , j, k) originally span ten data words (see packet 170 on the left-hand side of the figure). After rearranging, the variable values of the packet header are packed into only five data words (see phase 200), in an embodiment. Consequently, the number of calculation steps needed for calculating the final checksum are reduced considerably.

Note, however, that the variable values cannot be placed arbitrarily in the smaller set of data words. In order for the checksum calculation to be correct, each variable value should remain in the same relative position in the data words, i.e., in the same bit-significance. As seen by comparing column 170 (before rearranging) and column 200 (after rearranging), this property is met since each variable value is populated in the data words of column 200 (i) in exactly the same bit positions it had in column 170, and (ii) without overlap with other variable values. If the relative positions (bit-significances within the data words) of the variable values is preserved, the checksum calculation remains correct. At the same time, the number of clock cycles needed for calculating the final checksum is reduced.

The checksum calculation process of FIG. 6 is depicted solely by way of example. In alternative embodiments, the disclosed techniques can be carried out using any other suitable checksum calculation process. Another example, in which the above process is applied to a more complex packet, is described in U.S. Provisional Patent Application 62/591,590, cited above.

Although the embodiments described herein mainly address automotive networking applications, the methods and systems described herein can also be used in other applications, such as in live video streaming for monitoring or surveillance applications, live video and audio broadcast to video screens, Public Announcement (PA) equipment for concerts or public viewing events, having reduced delay between action on stage and video on the screens, or any other suitable application.

It is noted that the embodiments described above are cited by way of example, and that the present invention is not limited to what has been particularly shown and described hereinabove. Rather, the scope of the present invention includes both combinations and sub-combinations of the various features described hereinabove, as well as variations and modifications thereof which would occur to persons skilled in the art upon reading the foregoing description and which are not disclosed in the prior art. Documents incorporated by reference in the present patent application are to be considered an integral part of the application except that to the extent any terms are defined in these incorporated documents in a manner that conflicts with the definitions made explicitly or implicitly in the present specification, only the definitions in the present specification should be considered. 

The invention claimed is:
 1. A packet generator, comprising: a checksum calculator, configured to: distinguish, in a communication packet belonging to a sequence of communication packets, between (i) one or more constant values of a header of the communication packet, the one or more constant values remaining unchanged across the communication packets in the sequence, (ii) a payload of the communication packet, and (iii) one or more variable values of the header of the communication packet, wherein the one or more variable values span a first number of data words and change among the communication packets in the sequence; determine a constant-values partial checksum, which is calculated over the constant values of the header and remains unchanged across the communication packets in the sequence; calculate a payload partial checksum over the payload; calculate a final checksum value for the communication packet based on (i) the constant-values partial checksum, (ii) the payload partial checksum and (iii) the variable values of the header, by rearranging the variable values of the header in a second number of data words, smaller than the first number, and calculating the final checksum over the second number of data words; and insert the final checksum value into the communication packet; and an egress interface, configured to transmit the communication packet, including the final checksum value, over a communication network.
 2. The packet generator according to claim 1, wherein the checksum calculator is configured to determine the constant-values partial checksum and to calculate the payload partial checksum independently of one another.
 3. The packet generator according to claim 1, wherein the checksum calculator is configured to determine the constant-values partial checksum before the payload is received in the packet generator.
 4. The packet generator according to claim 1, wherein the checksum calculator is configured to calculate the constant-values partial checksum upon initialization of the packet generator and to store the calculated constant-values partial checksum in a memory, or to read from the memory an offline-calculated constant-values partial checksum.
 5. The packet generator according to claim 1, wherein the header of the communication packet spans one or more data words, and wherein the checksum calculator is configured to determine the constant-values partial checksum by zeroing any bits of the data words that do not belong to the constant values of the header, and then calculating the constant-values partial checksum over non-zeroed bits of the data words corresponding to the constant values.
 6. The packet generator according to claim 1, wherein the checksum calculator is configured to calculate the payload partial checksum over the payload in parallel with the payload being written into the memory buffer.
 7. The packet generator according to claim 1, wherein the checksum calculator is configured to calculate the final checksum value in parallel with transmission of the communication packet, and to complete calculation of the final checksum value and insertion of the final checksum value into the communication packet before a transmission time of the final checksum value.
 8. The packet generator according to claim 1, further comprising a transmit (TX) First-In First-Out (FIFO) buffer configured to hold at least the payload of the communication packet, wherein the checksum calculator comprises: input-side logic, which is coupled to an input of the FIFO buffer and configured to insert the payload partial checksum into a status word that propagates via the FIFO buffer together with the payload; and output-side logic, which is coupled to an output of the FIFO buffer and configured to extract the status word from the FIFO buffer, calculate the final checksum value based on the payload partial checksum in the status word, and insert the final checksum value into the communication packet.
 9. A packet generation method, comprising: in a communication packet belonging to a sequence of communication packets, distinguishing between (i) one or more constant values of a header of the communication packet, the one or more constant values remaining unchanged across the communication packets in the sequence, (ii) a payload of the communication packet, and (iii) one or more variable values of the header of the communication packet, wherein the one or more variable values span a first number of data words and change among the communication packets in the sequence; determining a constant-values partial checksum, which is calculated over the constant values of the header and remains unchanged across the communication packets in the sequence; calculating a payload partial checksum over the payload; calculating a final checksum value for the communication packet based on (i) the constant-values partial checksum, (ii) the payload partial checksum and (iii) the variable values of the header, by rearranging the variable values of the header in a second number of data words, smaller than the first number, and calculating the final checksum over the second number of data words; inserting the final checksum value into the communication packet; and transmitting the communication packet, including the final checksum value, over a communication network.
 10. The method according to claim 9, wherein determining the constant-values partial checksum and calculating the payload partial checksum are performed independently of one another.
 11. The method according to claim 9, wherein determining the constant-values partial checksum is performed before the payload is received in the packet generator.
 12. The method according to claim 9, wherein determining the constant-values partial checksum comprises calculating the constant-values partial checksum upon initialization of the packet generator and storing the calculated constant-values partial checksum in a memory, or reading from the memory an offline-calculated constant-values partial checksum.
 13. The method according to claim 9, wherein the header of the communication packet spans one or more data words, and wherein determining the constant-values partial checksum comprises zeroing any bits of the data words that do not belong to the constant values of the header, and then calculating the constant-values partial checksum over non-zeroed bits of the data words corresponding to the constant values.
 14. The method according to claim 9, wherein calculating the payload partial checksum over the payload is performed in parallel with the payload being written into the memory buffer.
 15. The method according to claim 9, wherein calculating the final checksum value comprises calculating the final checksum value in parallel with transmission of the communication packet, and completing calculation of the final checksum value and insertion of the final checksum value into the communication packet before a transmission time of the final checksum value.
 16. The packet generator according to claim 9, further comprising holding at least the payload of the communication packet in a transmit (TX) First-In First-Out (FIFO) buffer, wherein calculating the final checksum value comprises: inserting the payload partial checksum into a status word that propagates via the FIFO buffer together with the payload; and extracting the status word from the FIFO buffer, calculating the final checksum value based on the payload partial checksum in the status word, and inserting the final checksum value into the communication packet. 